use crate::ast::{ASTNode, Param};
use crate::interpreter::method::{Method, MethodType};
use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::rc::Rc;

/// 值的包装器，用于在HashSet中实现Hash和Eq
#[derive(Debug, Clone)]
pub struct ValueWrapper(pub Value);

impl PartialEq for ValueWrapper {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl Eq for ValueWrapper {}

impl std::hash::Hash for ValueWrapper {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        match &self.0.data {
            ValueData::Number(n) => {
                state.write_u8(0);
                // 使用标准的浮点数哈希方法，处理NaN和特殊值
                if n.is_nan() {
                    // 所有NaN值哈希到同一个值
                    state.write_u64(0xFFFFFFFFFFFFFFFF);
                } else {
                    n.to_bits().hash(state);
                }
            }
            ValueData::String(s) => {
                state.write_u8(1);
                s.hash(state);
            }
            ValueData::Boolean(b) => {
                state.write_u8(2);
                b.hash(state);
            }
            ValueData::Null => {
                state.write_u8(3);
            }
            ValueData::List(list) => {
                state.write_u8(4);
                // 对列表内容进行哈希，而不是使用内存地址
                let borrowed = list.borrow();
                state.write_usize(borrowed.len());
                for item in borrowed.iter() {
                    ValueWrapper(item.clone()).hash(state);
                }
            }
            ValueData::Dict(dict) => {
                state.write_u8(5);
                // 对字典内容进行哈希
                let borrowed = dict.borrow();
                state.write_usize(borrowed.len());
                // 使用BTreeMap确保顺序一致性
                let mut sorted_keys: Vec<_> = borrowed.keys().collect();
                sorted_keys.sort();
                for key in sorted_keys {
                    key.hash(state);
                    ValueWrapper(borrowed.get(key).unwrap().clone()).hash(state);
                }
            }
            ValueData::Set(set) => {
                state.write_u8(6);
                // 对集合内容进行哈希
                let borrowed = set.borrow();
                state.write_usize(borrowed.len());
                // 集合本身是无序的，但我们仍然需要对所有元素进行哈希
                for item in borrowed.iter() {
                    item.hash(state);
                }
            }
            ValueData::Tuple(tuple) => {
                state.write_u8(7);
                // 对元组内容进行哈希
                state.write_usize(tuple.len());
                for item in tuple.iter() {
                    ValueWrapper(item.clone()).hash(state);
                }
            }
            // 对于函数、闭包和对象类型，由于它们包含可变状态和行为，
            // 使用类型标识符和内存地址的组合作为哈希值
            ValueData::Closure(_) => {
                state.write_u8(8);
                state.write_u64(0xC108000000000000); // 闭包类型的特定标识符
                (&self.0 as *const Value).hash(state);
            }
            ValueData::Function {
                params,
                return_type,
                ..
            } => {
                state.write_u8(9);
                // 对函数的参数和返回类型进行哈希
                state.write_usize(params.len());
                for param in params {
                    param.name.hash(state);
                    if let Some(t) = &param.type_name {
                        t.hash(state);
                    }
                }
                if let Some(rt) = return_type {
                    rt.hash(state);
                }
            }
            ValueData::Object(_) => {
                state.write_u8(10);
                state.write_u64(0x0B1E700000000000); // 对象类型的特定标识符
                (&self.0 as *const Value).hash(state);
            }
        }
    }
}

/// 表示值的数据类型
#[derive(Debug, Clone)]
pub enum ValueData {
    /// 数字类型（统一为"数"）
    Number(f64),
    /// 字符串类型
    String(String),
    /// 布尔类型
    Boolean(bool),
    /// 列表类型
    List(Rc<RefCell<Vec<Value>>>),
    /// 字典类型
    Dict(Rc<RefCell<HashMap<String, Value>>>),
    /// 集合类型
    Set(Rc<RefCell<HashSet<ValueWrapper>>>),
    /// 元组类型
    Tuple(Vec<Value>),
    /// 闭包类型
    Closure(Rc<RefCell<HashMap<String, Value>>>),
    /// 函数类型
    Function {
        params: Vec<Param>,
        body: Vec<ASTNode>,
        closure: Rc<RefCell<HashMap<String, Value>>>,
        return_type: Option<String>,
    },
    /// 对象类型
    Object(Rc<RefCell<HashMap<String, Value>>>),
    /// 空类型
    Null,
}

/// 统一类型系统的根类型 - 道（Dao）\
#[derive(Debug, Clone)]
pub struct Value {
    /// 类型名称
    pub type_name: String,
    /// 实际数据
    pub data: ValueData,
    /// 方法表
    pub methods: Rc<RefCell<HashMap<String, Method>>>,
}

impl Value {
    /// 创建一个新的数字值
    pub fn number(n: f64) -> Self {
        let mut methods = HashMap::new();
        // 注册数字类型的内置方法
        methods.insert(
            "取整".to_string(),
            Method::native(MethodType::Number, |args| {
                if let ValueData::Number(n) = &args[0].data {
                    Ok(Value::number(n.floor()))
                } else {
                    Err("不是数字类型".to_string())
                }
            }),
        );

        methods.insert(
            "四舍五入".to_string(),
            Method::native(MethodType::Number, |args| {
                if let ValueData::Number(n) = &args[0].data {
                    Ok(Value::number(n.round()))
                } else {
                    Err("不是数字类型".to_string())
                }
            }),
        );

        methods.insert(
            "绝对值".to_string(),
            Method::native(MethodType::Number, |args| {
                if let ValueData::Number(n) = &args[0].data {
                    Ok(Value::number(n.abs()))
                } else {
                    Err("不是数字类型".to_string())
                }
            }),
        );

        methods.insert(
            "平方根".to_string(),
            Method::native(MethodType::Number, |args| {
                if let ValueData::Number(n) = &args[0].data {
                    Ok(Value::number(n.sqrt()))
                } else {
                    Err("不是数字类型".to_string())
                }
            }),
        );

        methods.insert(
            "幂".to_string(),
            Method::native(MethodType::Number, |args| {
                if let (ValueData::Number(base), ValueData::Number(exponent)) =
                    (&args[0].data, &args[1].data)
                {
                    Ok(Value::number(base.powf(*exponent)))
                } else {
                    Err("不是数字类型".to_string())
                }
            }),
        );

        // 添加通用方法
        Self::add_common_methods(&mut methods, "数");

        Value {
            type_name: "数".to_string(),
            data: ValueData::Number(n),
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的字符串值
    pub fn string(s: String) -> Self {
        let mut methods = HashMap::new();
        // 注册字符串类型的内置方法
        methods.insert(
            "长度".to_string(),
            Method::native(MethodType::String, |args| {
                if let ValueData::String(s) = &args[0].data {
                    Ok(Value::number(s.len() as f64))
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        methods.insert(
            "转大写".to_string(),
            Method::native(MethodType::String, |args| {
                if let ValueData::String(s) = &args[0].data {
                    Ok(Value::string(s.to_uppercase()))
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        methods.insert(
            "转小写".to_string(),
            Method::native(MethodType::String, |args| {
                if let ValueData::String(s) = &args[0].data {
                    Ok(Value::string(s.to_lowercase()))
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        methods.insert(
            "分割".to_string(),
            Method::native(MethodType::String, |args| {
                if let (ValueData::String(s), ValueData::String(delimiter)) =
                    (&args[0].data, &args[1].data)
                {
                    let parts = s
                        .split(delimiter)
                        .map(|part| Value::string(part.to_string()))
                        .collect();
                    Ok(Value::list(parts))
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        methods.insert(
            "替换".to_string(),
            Method::native(MethodType::String, |args| {
                if let (ValueData::String(s), ValueData::String(old), ValueData::String(new)) =
                    (&args[0].data, &args[1].data, &args[2].data)
                {
                    Ok(Value::string(s.replace(old, new)))
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        methods.insert(
            "查找".to_string(),
            Method::native(MethodType::String, |args| {
                if let (ValueData::String(s), ValueData::String(sub)) =
                    (&args[0].data, &args[1].data)
                {
                    match s.find(sub) {
                        Some(index) => Ok(Value::number(index as f64)),
                        None => Ok(Value::number(-1.0)),
                    }
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        methods.insert(
            "截取".to_string(),
            Method::native(MethodType::String, |args| {
                if let (ValueData::String(s), ValueData::Number(start), ValueData::Number(end)) =
                    (&args[0].data, &args[1].data, &args[2].data)
                {
                    let start_idx = *start as usize;
                    let end_idx = *end as usize;
                    if start_idx <= end_idx && end_idx <= s.len() {
                        Ok(Value::string(s[start_idx..end_idx].to_string()))
                    } else {
                        Err("索引超出范围".to_string())
                    }
                } else {
                    Err("不是字符串类型".to_string())
                }
            }),
        );

        // 添加通用方法
        Self::add_common_methods(&mut methods, "文");

        Value {
            type_name: "文".to_string(),
            data: ValueData::String(s),
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的布尔值
    pub fn boolean(b: bool) -> Self {
        let mut methods = HashMap::new();

        // 注册布尔类型的内置方法
        methods.insert(
            "转串".to_string(),
            Method::native(MethodType::Boolean, |args| {
                if let ValueData::Boolean(b) = &args[0].data {
                    Ok(Value::string(if *b { "真" } else { "伪" }.to_string()))
                } else {
                    Err("不是布尔类型".to_string())
                }
            }),
        );

        // 添加通用方法
        Self::add_common_methods(&mut methods, "真伪");

        Value {
            type_name: "真伪".to_string(),
            data: ValueData::Boolean(b),
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的空值
    pub fn null() -> Self {
        let mut methods = HashMap::new();

        // 添加通用方法
        Self::add_common_methods(&mut methods, "无");

        Value {
            type_name: "无".to_string(),
            data: ValueData::Null,
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的列表
    pub fn list(elements: Vec<Value>) -> Self {
        crate::interpreter::collections::List::create(elements)
    }

    /// 创建一个新的字典
    pub fn dict(items: HashMap<String, Value>) -> Self {
        crate::interpreter::collections::Dict::create(items)
    }

    /// 创建一个新的函数
    pub fn function(
        params: Vec<Param>,
        body: Vec<ASTNode>,
        closure: HashMap<String, Value>,
        return_type: Option<String>,
    ) -> Self {
        let mut methods = HashMap::new();

        // 添加通用方法
        Self::add_common_methods(&mut methods, "函");

        Value {
            type_name: "函".to_string(),
            data: ValueData::Function {
                params,
                body,
                closure: Rc::new(RefCell::new(closure)),
                return_type,
            },
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的对象
    pub fn object(fields: HashMap<String, Value>) -> Self {
        let mut methods = HashMap::new();

        // 添加通用方法
        Self::add_common_methods(&mut methods, "物");

        Value {
            type_name: "物".to_string(),
            data: ValueData::Object(Rc::new(RefCell::new(fields))),
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的类实例，包含类的方法
    pub fn class_instance(
        class_name: &str,
        class_fields: &HashMap<String, Value>,
        class_methods: &HashMap<String, Method>,
    ) -> Self {
        let mut methods = HashMap::new();

        // 复制类的方法到实例
        for (method_name, method) in class_methods {
            methods.insert(method_name.clone(), method.clone());
        }

        // 添加通用方法
        Self::add_common_methods(&mut methods, "物");

        Value {
            type_name: class_name.to_string(),
            data: ValueData::Object(Rc::new(RefCell::new(class_fields.clone()))),
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 创建一个新的元组
    pub fn tuple(items: Vec<Value>) -> Self {
        crate::interpreter::collections::Tuple::create(items)
    }

    /// 创建一个新的集合，自动去重
    pub fn set(items: Vec<Value>) -> Self {
        crate::interpreter::collections::Set::create(items)
    }

    /// 获取类型名称
    pub fn get_type_name(&self) -> String {
        self.type_name.clone()
    }

    /// 获取方法类型
    pub fn get_type(&self) -> MethodType {
        match self.type_name.as_str() {
            "数" => MethodType::Number,
            "文" => MethodType::String,
            "真伪" => MethodType::Boolean,
            "集" => MethodType::List,
            "辞" => MethodType::Dict,
            "汇" => MethodType::Set,
            "组" => MethodType::Tuple,
            "函" => MethodType::Function,
            "物" => MethodType::Object,
            "无" => MethodType::Null,
            _ => MethodType::Any,
        }
    }

    /// 为所有类型添加通用方法
    pub fn add_common_methods(methods: &mut HashMap<String, Method>, _type_name: &str) {
        // 注册类型()方法，返回类型名称
        methods.insert(
            "类型".to_string(),
            Method::native(MethodType::Generic, |args| {
                Ok(Value::string(args[0].get_type_name()))
            }),
        );

        // 注册转串()方法，将值转换为字符串
        methods.insert(
            "转串".to_string(),
            Method::native(MethodType::Generic, |args| {
                Ok(Value::string(args[0].to_string()))
            }),
        );

        // 注册真假()方法，判断值的真假性
        methods.insert(
            "真假".to_string(),
            Method::native(MethodType::Generic, |args| Ok(args[0].to_boolean())),
        );

        // 注册转数()方法，将值转换为数字
        methods.insert(
            "转数".to_string(),
            Method::native(MethodType::Generic, |args| args[0].to_number()),
        );

        // 注册转真伪()方法，将值转换为布尔值
        methods.insert(
            "转真伪".to_string(),
            Method::native(MethodType::Generic, |args| Ok(args[0].to_boolean())),
        );
    }

    /// 类型扩展：添加自定义方法
    pub fn add_method(&mut self, name: String, method: Method) {
        self.methods.borrow_mut().insert(name, method);
    }

    /// 类型扩展：添加自定义类型
    pub fn custom_type(name: String, data: ValueData) -> Self {
        let mut methods = HashMap::new();

        // 添加通用方法
        Self::add_common_methods(&mut methods, &name);

        Value {
            type_name: name,
            data,
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 调用方法
    pub fn call_method(&self, name: &str, args: &[Value]) -> Result<Value, String> {
        // 首先检查方法表中是否有方法
        if let Some(method) = self.methods.borrow().get(name) {
            let mut full_args = vec![self.clone()];
            for arg in args {
                full_args.push(arg.clone());
            }
            return method.call(&full_args);
        }

        // 如果没有找到方法，检查对象字段中是否有函数
        if let ValueData::Object(fields) = &self.data {
            let fields_ref = fields.borrow();
            if let Some(field_value) = fields_ref.get(name) {
                // 检查字段值是否是函数
                if let ValueData::Function { .. } = &field_value.data {
                    // 这是一个函数字段，需要解释器来执行它
                    // 但我们目前没有解释器上下文，所以返回错误
                    return Err("对象方法调用需要解释器环境".to_string());
                }
            }
        }

        Err(format!("方法不存在: {}", name))
    }

    /// 类型转换：转数字
    pub fn to_number(&self) -> Result<Value, String> {
        match &self.data {
            ValueData::Number(n) => Ok(Value::number(*n)),
            ValueData::String(s) => {
                // 支持中文数字转换
                if let Ok(n) = s.parse::<f64>() {
                    Ok(Value::number(n))
                } else {
                    // 简单的中文数字转换支持
                    match s.as_str() {
                        "零" => Ok(Value::number(0.0)),
                        "一" => Ok(Value::number(1.0)),
                        "二" => Ok(Value::number(2.0)),
                        "三" => Ok(Value::number(3.0)),
                        "四" => Ok(Value::number(4.0)),
                        "五" => Ok(Value::number(5.0)),
                        "六" => Ok(Value::number(6.0)),
                        "七" => Ok(Value::number(7.0)),
                        "八" => Ok(Value::number(8.0)),
                        "九" => Ok(Value::number(9.0)),
                        "十" => Ok(Value::number(10.0)),
                        _ => Err("无法转换为数字".to_string()),
                    }
                }
            }
            ValueData::Boolean(b) => Ok(Value::number(if *b { 1.0 } else { 0.0 })),
            ValueData::Null => Ok(Value::number(0.0)),
            // 空列表/字典/集合转换为0
            ValueData::List(elements) => Ok(Value::number(if elements.borrow().is_empty() {
                0.0
            } else {
                1.0
            })),
            ValueData::Dict(items) => Ok(Value::number(if items.borrow().is_empty() {
                0.0
            } else {
                1.0
            })),
            ValueData::Set(items) => Ok(Value::number(if items.borrow().is_empty() {
                0.0
            } else {
                1.0
            })),
            // 其他类型默认转换为1
            _ => Ok(Value::number(1.0)),
        }
    }

    /// 类型转换：转字符串
    pub fn to_string(&self) -> String {
        self.to_string_with_indent(0, &mut std::collections::HashSet::new())
    }

    /// 带缩进的字符串转换，用于格式化嵌套集合
    /// visited参数用于跟踪已经访问过的值，防止循环引用
    pub fn to_string_with_indent(
        &self,
        indent: usize,
        visited: &mut std::collections::HashSet<usize>,
    ) -> String {
        // 使用值的内存地址作为唯一标识
        let ptr = self as *const Self as usize;

        // 如果已经访问过这个值，说明有循环引用，返回特殊标记
        if visited.contains(&ptr) {
            return "<循环引用>".to_string();
        }

        // 对于集合类型，添加到已访问集合中
        match &self.data {
            ValueData::List(_) | ValueData::Dict(_) | ValueData::Set(_) | ValueData::Tuple(_) => {
                visited.insert(ptr);
            }
            _ => {}
        }

        let result = match &self.data {
            ValueData::Number(n) => {
                // 智能显示：整数不显示小数点
                if *n == n.floor() {
                    format!("{}", *n as i64)
                } else {
                    format!("{}", n)
                }
            }
            ValueData::String(s) => s.clone(),
            ValueData::Boolean(b) => if *b { "真" } else { "伪" }.to_string(),
            ValueData::List(elements) => {
                let elems = elements.borrow();
                if elems.is_empty() {
                    "【】".to_string()
                } else {
                    // 检查是否有嵌套集合
                    let has_nested = elems.iter().any(|v| {
                        matches!(
                            &v.data,
                            ValueData::List(_)
                                | ValueData::Dict(_)
                                | ValueData::Set(_)
                                | ValueData::Tuple(_)
                        )
                    });

                    if has_nested {
                        // 格式化嵌套集合
                        let mut result: String = "".to_string();
                        for (i, v) in elems.iter().enumerate() {
                            let nested_str = v.to_string_with_indent(indent + 1, visited);
                            result.push_str(&"  ".repeat(indent + 1));
                            result.push_str(&nested_str);
                            if i < elems.len() - 1 {
                                result.push_str("、");
                            }
                            result.push('\n');
                        }
                        //result.push_str(&"".repeat(indent));
                        //result.push('');
                        result
                    } else {
                        // 简单列表，单行显示
                        let elems_str: Vec<String> = elems.iter().map(|v| v.to_string()).collect();
                        format!("【{}】", elems_str.join("、"))
                    }
                }
            }
            ValueData::Dict(items) => {
                let items_ref = items.borrow();
                if items_ref.is_empty() {
                    "辞".to_string()
                } else {
                    // 检查是否有嵌套集合
                    let has_nested = items_ref.values().any(|v| {
                        matches!(
                            &v.data,
                            ValueData::List(_)
                                | ValueData::Dict(_)
                                | ValueData::Set(_)
                                | ValueData::Tuple(_)
                        )
                    });

                    if has_nested {
                        // 格式化嵌套字典 - 使用更清晰的缩进格式
                        let mut result = "《\n".to_string();

                        for (i, (k, v)) in items_ref.iter().enumerate() {
                            // 添加缩进和键
                            result.push_str(&"  ".repeat(indent + 1));
                            result.push_str(&format!("「{}」： ", k));

                            // 处理值
                            if let ValueData::Dict(_) = &v.data {
                                // 嵌套字典，递归格式化
                                result.push_str(&v.to_string_with_indent(indent + 1, visited));
                            } else {
                                // 非嵌套值
                                result.push_str(&v.to_string_with_indent(0, visited));
                            }

                            // 添加分隔符和换行
                            if i < items_ref.len() - 1 {
                                result.push_str("、");
                            }
                            result.push('\n');
                        }

                        // 添加结束符号和缩进
                        result.push_str(&"  ".repeat(indent));
                        result.push_str("》");
                        result
                    } else {
                        // 简单字典，单行显示
                        let pairs: Vec<String> = items_ref
                            .iter()
                            .map(|(k, v)| format!("「{}」： {}", k, v.to_string()))
                            .collect();
                        format!("《{}》", pairs.join("、"))
                    }
                }
            }
            ValueData::Set(items) => {
                let items_ref = items.borrow();
                if items_ref.is_empty() {
                    "{}".to_string()
                } else {
                    // 检查是否有嵌套集合
                    let has_nested = items_ref.iter().any(|v| {
                        matches!(
                            &v.0.data,
                            ValueData::List(_)
                                | ValueData::Dict(_)
                                | ValueData::Set(_)
                                | ValueData::Tuple(_)
                        )
                    });

                    if has_nested {
                        // 格式化嵌套集合 - 使用更清晰的格式
                        let mut result = "{\n".to_string();
                        let items: Vec<Value> = items_ref.iter().map(|v| v.0.clone()).collect();
                        for (i, v) in items.iter().enumerate() {
                            result.push_str(&"  ".repeat(indent + 1));

                            // 对于嵌套的汇类型，使用更紧凑的格式
                            if let ValueData::Set(_) = &v.data {
                                // 直接处理嵌套汇类型，避免递归调用
                                let nested_items = match &v.data {
                                    ValueData::Set(nested_items) => nested_items.borrow().clone(),
                                    _ => unreachable!(),
                                };

                                if nested_items.is_empty() {
                                    result.push_str("{}");
                                } else {
                                    // 检查嵌套汇类型是否还有嵌套
                                    let has_deep_nested = nested_items.iter().any(|v| {
                                        matches!(
                                            &v.0.data,
                                            ValueData::List(_)
                                                | ValueData::Dict(_)
                                                | ValueData::Set(_)
                                                | ValueData::Tuple(_)
                                        )
                                    });

                                    if has_deep_nested {
                                        // 有深层嵌套，使用多行格式
                                        result.push_str("{\n");
                                        for (j, nested_v) in nested_items.iter().enumerate() {
                                            result.push_str(&"  ".repeat(indent + 2));
                                            // 对于嵌套汇类型，直接处理其内容
                                            if let ValueData::Set(deep_nested_items) =
                                                &nested_v.0.data
                                            {
                                                let deep_items = deep_nested_items.borrow();
                                                if deep_items.is_empty() {
                                                    result.push_str("{}");
                                                } else {
                                                    let deep_elems_str: Vec<String> = deep_items
                                                        .iter()
                                                        .map(|v| v.0.to_string())
                                                        .collect();
                                                    result.push_str(&format!(
                                                        "{{{}}}",
                                                        deep_elems_str.join("、")
                                                    ));
                                                }
                                            } else {
                                                let nested_str = nested_v
                                                    .0
                                                    .to_string_with_indent(indent + 2, visited);
                                                result.push_str(&nested_str);
                                            }
                                            if j < nested_items.len() - 1 {
                                                result.push_str("、");
                                            }
                                            result.push('\n');
                                        }
                                        result.push_str(&"  ".repeat(indent + 1));
                                        result.push('}');
                                    } else {
                                        // 简单嵌套汇类型，单行显示
                                        let elems_str: Vec<String> =
                                            nested_items.iter().map(|v| v.0.to_string()).collect();
                                        result.push_str(&format!("{{{}}}", elems_str.join("、")));
                                    }
                                }
                            } else {
                                // 非汇类型的嵌套元素
                                let nested_str = v.to_string_with_indent(indent + 1, visited);
                                result.push_str(&nested_str);
                            }

                            if i < items.len() - 1 {
                                result.push_str("、");
                            }
                            result.push('\n');
                        }
                        result.push_str(&"  ".repeat(indent));
                        result.push('}');
                        result
                    } else {
                        // 简单集合，单行显示
                        let elems_str: Vec<String> =
                            items_ref.iter().map(|v| v.0.to_string()).collect();
                        format!("{{{}}}", elems_str.join("、"))
                    }
                }
            }
            ValueData::Tuple(items) => {
                if items.is_empty() {
                    "【】".to_string()
                } else {
                    // 检查是否有嵌套集合
                    let has_nested = items.iter().any(|v| {
                        matches!(
                            &v.data,
                            ValueData::List(_)
                                | ValueData::Dict(_)
                                | ValueData::Set(_)
                                | ValueData::Tuple(_)
                        )
                    });

                    if has_nested {
                        // 格式化嵌套集合
                        let mut result = "【\n".to_string();
                        for (i, v) in items.iter().enumerate() {
                            let nested_str = v.to_string_with_indent(indent + 1, visited);
                            result.push_str(&"  ".repeat(indent + 1));
                            result.push_str(&nested_str);
                            if i < items.len() - 1 {
                                result.push_str("、");
                            }
                            result.push('\n');
                        }
                        result.push_str(&"  ".repeat(indent));
                        result.push('】');
                        result
                    } else {
                        // 简单元组，单行显示
                        let elems_str: Vec<String> = items.iter().map(|v| v.to_string()).collect();
                        format!("【{}】", elems_str.join("、"))
                    }
                }
            }
            ValueData::Function { .. } => "<函>".to_string(),
            ValueData::Closure(_) => "<闭>".to_string(),
            ValueData::Object { .. } => "<物>".to_string(),
            ValueData::Null => "无".to_string(),
        };

        // 对于集合类型，从已访问集合中移除
        match &self.data {
            ValueData::List(_) | ValueData::Dict(_) | ValueData::Set(_) | ValueData::Tuple(_) => {
                visited.remove(&ptr);
            }
            _ => {}
        }

        result
    }

    /// 类型转换：转布尔
    pub fn to_boolean(&self) -> Value {
        let is_truthy = match &self.data {
            // 布尔类型直接返回
            ValueData::Boolean(b) => *b,
            // 数字：0为假，其他为真
            ValueData::Number(n) => *n != 0.0,
            // 字符串：空字符串为假，其他为真
            ValueData::String(s) => !s.is_empty(),
            // 空值为假
            ValueData::Null => false,
            // 列表：空列表为假，其他为真
            ValueData::List(elements) => !elements.borrow().is_empty(),
            // 字典：空字典为假，其他为真
            ValueData::Dict(items) => !items.borrow().is_empty(),
            // 集合：空集合为假，其他为真
            ValueData::Set(items) => !items.borrow().is_empty(),
            // 元组：空元组为假，其他为真
            ValueData::Tuple(items) => !items.is_empty(),
            // 闭包：始终为真
            ValueData::Closure(_) => true,
            // 函数：始终为真
            ValueData::Function { .. } => true,
            // 对象：始终为真
            ValueData::Object { .. } => true,
        };
        Value::boolean(is_truthy)
    }
}

// 手动实现PartialEq for Value，因为Method包含函数指针，无法自动派生
impl PartialEq for Value {
    fn eq(&self, other: &Self) -> bool {
        // 只比较数据，不比较方法表
        self.type_name == other.type_name && self.data == other.data
    }
}

// 实现PartialEq for ValueData，比较两个值的数据是否相同
impl PartialEq for ValueData {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (ValueData::Number(n1), ValueData::Number(n2)) => n1 == n2,
            (ValueData::String(s1), ValueData::String(s2)) => s1 == s2,
            (ValueData::Boolean(b1), ValueData::Boolean(b2)) => b1 == b2,
            (ValueData::Null, ValueData::Null) => true,
            (ValueData::List(l1), ValueData::List(l2)) => {
                // 比较两个列表的内容
                let l1 = l1.borrow();
                let l2 = l2.borrow();
                if l1.len() != l2.len() {
                    return false;
                }
                for (a, b) in l1.iter().zip(l2.iter()) {
                    if a != b {
                        return false;
                    }
                }
                true
            }
            (ValueData::Dict(d1), ValueData::Dict(d2)) => {
                // 比较两个字典的内容
                let d1 = d1.borrow();
                let d2 = d2.borrow();
                if d1.len() != d2.len() {
                    return false;
                }
                for (k, v1) in d1.iter() {
                    if let Some(v2) = d2.get(k) {
                        if v1 != v2 {
                            return false;
                        }
                    } else {
                        return false;
                    }
                }
                true
            }
            (ValueData::Set(s1), ValueData::Set(s2)) => {
                // 比较两个集合的元素是否相同，不考虑顺序
                let s1 = s1.borrow();
                let s2 = s2.borrow();
                if s1.len() != s2.len() {
                    return false;
                }
                for item in s1.iter() {
                    if !s2.contains(item) {
                        return false;
                    }
                }
                true
            }
            (ValueData::Tuple(t1), ValueData::Tuple(t2)) => t1 == t2,
            // 函数和对象比较指针
            (ValueData::Function { closure: c1, .. }, ValueData::Function { closure: c2, .. }) => {
                // 简化实现，只比较指针是否相同
                Rc::ptr_eq(c1, c2)
            }
            (ValueData::Object { .. }, ValueData::Object { .. }) => {
                // 简化实现，只比较类型名称
                self == other
            }
            _ => false,
        }
    }
}
